interview

Home / DeveloperSection / Interviews / How to get the sizeof() a datatype in C#?

Ask Question
Ravi Vishwakarma

Ravi Vishwakarma

Follow
Hi, my self Ravi Vishwakarma. I have completed my studies at SPICBB Varanasi. now I completed MCA with 76% form Veer Bahadur Singh Purvanchal University Jaunpur. SWE @ MindStick | Software Engineer | Web Developer | .Net Developer | Web Developer | Backend Engineer | .NET Core Developer

Can you answer this question?

Answer

1 Answers

Ravi Vishwakarma

Ravi Vishwakarma

07-Jun-2024

In C#, you could determine the scale of a cost kind the usage of the sizeof the operator or the Marshal.SizeOf technique from the System.Runtime.InteropServices namespace. However, the sizeof the operator can only be used with unmanaged sorts and inside a risky context. For managed kinds or preferred utilization, Marshal.SizeOf is more suitable.

Here are examples of each strategy:

Using sizeof Operator
The sizeof the operator is used in a hazardous context to get the scale of unmanaged kinds. Unmanaged types include primitive information sorts (like int, flow, etc.) and person-described structs that don't contain any reference sorts.

using System;
namespace ConsoleApplication1
{
    public class CheckSizeof
    {
        unsafe public static void Main()
        {
            // Example of using sizeof operator
            Console.WriteLine("Size of int: {0} bytes", sizeof(int));
            Console.WriteLine("Size of double: {0} bytes", sizeof(double));
            Console.WriteLine("Size of char: {0} bytes", sizeof(char));
            Console.WriteLine("Size of DemoStruct: {0} bytes", sizeof(DemoStruct));
            Console.ReadLine();
        }

        //Create a DemoStruct of struct datatype
        struct DemoStruct
        {
            char ch;
            int x;
            float y;
            double z;
        }
    }
}

Note: To use the sizeof operator, you need to assemble with the /hazardous option and mark your code with the risky keyword.

Using Marshal.SizeOf Method
The Marshal.SizeOf approach can be used with both managed and unmanaged types and does no longer require an unsafe context.

using System;
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
    public class CheckSizeof
    {
        static void Main()
        {
            // Example of using Marshal.SizeOf method
            Console.WriteLine("Size of int: {0} bytes", Marshal.SizeOf(typeof(int)));
            Console.WriteLine("Size of double: {0} bytes", Marshal.SizeOf(typeof(double)));
            Console.WriteLine("Size of char: {0} bytes", Marshal.SizeOf(typeof(char)));

            // Example with a custom struct
            Console.WriteLine("Size of MyStruct: {0} bytes", Marshal.SizeOf(typeof(MyStruct)));
            Console.ReadLine();
        }

        struct MyStruct
        {
            public int x;
            public double y;
            public char z;
        }
    }
}

Explanation:
Using sizeof: 

  1. Only works with primitive types and calls for risky code.
  2. Provides the dimensions in bytes of the specified type.

Using Marshal.SizeOf:

  1. Works with both controlled and unmanaged sorts.
  2. Does no longer requires risky code.
  3. The Marshal.SizeOf technique returns the size in bytes of the specified type.

Choose the approach that first-rate suits your necessities and the context in which you're running. For maximum fashionable functions, Marshal.SizeOf is more versatile and less difficult to apply because it does now not require an unsafe context.

MindStick Training

Liked By